home *** CD-ROM | disk | FTP | other *** search
/ QuickTime 2.0 Developer Kit / QuickTime 2.0 Developer Kit.iso / mac / MAC / Programming Stuff / Interfaces / PInterfaces / Power.p < prev    next >
Encoding:
Text File  |  1994-11-11  |  11.4 KB  |  392 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Power.p
  3.  
  4.      Copyright:    © 1984-1994 by Apple Computer, Inc.
  5.                  All rights reserved.
  6.  
  7.      Version:    Universal Interfaces 2.0a3  ETO #16, MPW prerelease.  Friday, November 11, 1994. 
  8.  
  9.      Bugs?:        If you find a problem with this file, send the file and version
  10.                  information (from above) and the problem description to:
  11.  
  12.                      Internet:    apple.bugs@applelink.apple.com
  13.                      AppleLink:    APPLE.BUGS
  14.  
  15. }
  16.  
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Power;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __POWER__}
  27. {$SETC __POWER__ := 1}
  28.  
  29. {$I+}
  30. {$SETC PowerIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {    ConditionalMacros.p                                            }
  38.  
  39. {$IFC UNDEFINED __MIXEDMODE__}
  40. {$I MixedMode.p}
  41. {$ENDC}
  42.  
  43. {$PUSH}
  44. {$ALIGN MAC68K}
  45. {$LibExport+}
  46.  
  47. CONST
  48. { Bit positions for ModemByte }
  49.     modemOnBit                    = 0;
  50.     ringWakeUpBit                = 2;
  51.     modemInstalledBit            = 3;
  52.     ringDetectBit                = 4;
  53.     modemOnHookBit                = 5;
  54. { masks for ModemByte }
  55.     modemOnMask                    = $1;
  56.     ringWakeUpMask                = $4;
  57.     modemInstalledMask            = $8;
  58.     ringDetectMask                = $10;
  59.     modemOnHookMask                = $20;
  60. { bit positions for BatteryByte }
  61.     chargerConnBit                = 0;
  62.     hiChargeBit                    = 1;
  63.     chargeOverFlowBit            = 2;
  64.     batteryDeadBit                = 3;
  65.     batteryLowBit                = 4;
  66.     connChangedBit                = 5;
  67. { masks for BatteryByte }
  68.     chargerConnMask                = $1;
  69.     hiChargeMask                = $2;
  70.     chargeOverFlowMask            = $4;
  71.     batteryDeadMask                = $8;
  72.  
  73.     batteryLowMask                = $10;
  74.     connChangedMask                = $20;
  75. { commands to SleepQRec sleepQProc }
  76.     sleepRequest                = 1;
  77.     sleepDemand                    = 2;
  78.     sleepWakeUp                    = 3;
  79.     sleepRevoke                    = 4;
  80. { SleepQRec.sleepQFlags }
  81.     noCalls                        = 1;
  82.     noRequest                    = 2;
  83.     slpQType                    = 16;
  84.     sleepQType                    = 16;
  85.  
  86. { bits in bitfield returned by PMFeatures }
  87.     hasWakeupTimer                = 0;                            { 1=wakeup timer is supported                        }
  88.     hasSharedModemPort            = 1;                            { 1=modem port shared by SCC and internal modem    }
  89.     hasProcessorCycling            = 2;                            { 1=processor cycling is supported                    }
  90.     mustProcessorCycle            = 3;                            { 1=processor cycling should not be turned off        }
  91.     hasReducedSpeed                = 4;                            { 1=processor can be started up at reduced speed    }
  92.     dynamicSpeedChange            = 5;                            { 1=processor speed can be switched dynamically    }
  93.     hasSCSIDiskMode                = 6;                            { 1=SCSI Disk Mode is supported                    }
  94.     canGetBatteryTime            = 7;                            { 1=battery time can be calculated                    }
  95.     canWakeupOnRing                = 8;                            { 1=can wakeup when the modem detects a ring        }
  96.     hasDimmingSupport            = 9;                            { 1 has dimming support built into the rom            }
  97.  
  98. { bits in bitfield returned by GetIntModemInfo and set by SetIntModemState }
  99.     hasInternalModem            = 0;                            { 1=internal modem installed                        }
  100.     intModemRingDetect            = 1;                            { 1=internal modem has detected a ring                }
  101.     intModemOffHook                = 2;                            { 1=internal modem is off hook                        }
  102.     intModemRingWakeEnb            = 3;                            { 1=wakeup on ring is enabled                        }
  103.     extModemSelected            = 4;                            { 1=external modem selected                        }
  104.     modemSetBit                    = 15;                            { 1=set bit, 0=clear bit (SetIntModemState)        }
  105.  
  106. { bits in BatteryInfo.flags                                     }
  107. { ("chargerConnected" doesn't mean the charger is plugged in)    }
  108.     batteryInstalled            = 7;                            { 1=battery is currently connected                    }
  109.     batteryCharging                = 6;                            { 1=battery is being charged                        }
  110.     chargerConnected            = 5;                            { 1=charger is connected to the PowerBook            }
  111.  
  112.     HDPwrQType                    = 'HD';
  113.  
  114.  
  115. TYPE
  116.     BatteryInfo = PACKED RECORD
  117.         flags:                    UInt8;                                    { misc flags (see below)                            }
  118.         warningLevel:            UInt8;                                    { scaled warning level (0-255)                        }
  119.         reserved:                UInt8;                                    { reserved for internal use                        }
  120.         batteryLevel:            UInt8;                                    { scaled battery level (0-255)                        }
  121.     END;
  122.     ModemByte = SInt8;
  123.  
  124.     BatteryByte = SInt8;
  125.  
  126.     PMResultCode = LONGINT;
  127.  
  128.     SleepQRecPtr = ^SleepQRec;
  129.  
  130.     HDSpindownProcPtr = ProcPtr;  { PROCEDURE HDSpindown(VAR theElement: HDQueueElement); }
  131.     {
  132.         SleepQProcPtr uses register based parameters on the 68k and cannot
  133.         be written in or called from a high-level language without the help of
  134.         mixed mode or assembly glue.
  135.  
  136.         In:
  137.          => message         D0.L
  138.          => qRecPtr         A0.L
  139.         Out:
  140.          <= return value    D0.L
  141.     }
  142.     SleepQProcPtr = ProcPtr;  { FUNCTION SleepQ(message: LONGINT; qRecPtr: SleepQRecPtr): LONGINT; }
  143.     HDSpindownUPP = UniversalProcPtr;
  144.     SleepQUPP = UniversalProcPtr;
  145.  
  146.     HDQueueElement = RECORD
  147.         hdQLink:                Ptr;                                    { pointer to next queue element                    }
  148.         hdQType:                INTEGER;                                { queue element type (must be HDQType)                }
  149.         hdFlags:                INTEGER;                                { miscellaneous flags                                }
  150.         hdProc:                    HDSpindownUPP;                            { pointer to routine to call                        }
  151.         hdUser:                    LONGINT;                                { user-defined (variable storage, etc.)            }
  152.     END;
  153.     SleepQRec = RECORD
  154.         sleepQLink:                ^SleepQRec;
  155.         sleepQType:                INTEGER;                                { type = 16                            }
  156.         sleepQProc:                SleepQUPP;                                { Pointer to sleep universal proc ptr    }
  157.         sleepQFlags:            INTEGER;
  158.     END;
  159. { wakeup time record }
  160.     WakeupTime = RECORD
  161.         wakeTime:                LONGINT;                                { wakeup time (same format as current time)        }
  162.         wakeEnabled:            BOOLEAN;                                { 1=enable wakeup timer, 0=disable wakeup timer    }
  163.     END;
  164. { battery time information (in seconds) }
  165.     BatteryTimeRec = RECORD
  166.         expectedBatteryTime:    LONGINT;                                { estimated battery time remaining                }
  167.         minimumBatteryTime:        LONGINT;                                { minimum battery time remaining                }
  168.         maximumBatteryTime:        LONGINT;                                { maximum battery time remaining                }
  169.         timeUntilCharged:        LONGINT;                                { time until battery is fully charged            }
  170.     END;
  171.  
  172. FUNCTION DisableWUTime: OSErr;
  173. FUNCTION SetWUTime(WUTime: LONGINT): OSErr;
  174. FUNCTION GetWUTime(VAR WUTime: LONGINT; VAR WUFlag: SignedByte): OSErr;
  175. FUNCTION BatteryStatus(VAR Status: SignedByte; VAR Power: SignedByte): OSErr;
  176. FUNCTION ModemStatus(VAR Status: SignedByte): OSErr;
  177. FUNCTION IdleUpdate: LONGINT;
  178.     {$IFC NOT GENERATINGCFM}
  179.     INLINE $A285, $2E80;
  180.     {$ENDC}
  181. FUNCTION GetCPUSpeed: LONGINT;
  182.     {$IFC NOT GENERATINGCFM}
  183.     INLINE $70FF, $A485, $2E80;
  184.     {$ENDC}
  185. PROCEDURE EnableIdle;
  186.     {$IFC NOT GENERATINGCFM}
  187.     INLINE $7000, $A485;
  188.     {$ENDC}
  189. PROCEDURE DisableIdle;
  190.     {$IFC NOT GENERATINGCFM}
  191.     INLINE $7001, $A485;
  192.     {$ENDC}
  193. PROCEDURE SleepQInstall(qRecPtr: SleepQRecPtr);
  194.     {$IFC NOT GENERATINGCFM}
  195.     INLINE $205F, $A28A;
  196.     {$ENDC}
  197. PROCEDURE SleepQRemove(qRecPtr: SleepQRecPtr);
  198.     {$IFC NOT GENERATINGCFM}
  199.     INLINE $205F, $A48A;
  200.     {$ENDC}
  201. PROCEDURE AOn;
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $7004, $A685;
  204.     {$ENDC}
  205. PROCEDURE AOnIgnoreModem;
  206.     {$IFC NOT GENERATINGCFM}
  207.     INLINE $7005, $A685;
  208.     {$ENDC}
  209. PROCEDURE BOn;
  210.     {$IFC NOT GENERATINGCFM}
  211.     INLINE $7000, $A685;
  212.     {$ENDC}
  213. PROCEDURE AOff;
  214.     {$IFC NOT GENERATINGCFM}
  215.     INLINE $7084, $A685;
  216.     {$ENDC}
  217. PROCEDURE BOff;
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $7080, $A685;
  220.     {$ENDC}
  221. { Public Power Management API (NEW!) }
  222. FUNCTION PMSelectorCount: INTEGER;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $7000, $A09E, $3E80;
  225.     {$ENDC}
  226. FUNCTION PMFeatures: LONGINT;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $7001, $A09E, $2E80;
  229.     {$ENDC}
  230. FUNCTION GetSleepTimeout: UInt8;
  231.     {$IFC NOT GENERATINGCFM}
  232.     INLINE $7002, $A09E, $1E80;
  233.     {$ENDC}
  234. PROCEDURE SetSleepTimeout(timeout: ByteParameter);
  235.     {$IFC NOT GENERATINGCFM}
  236.     INLINE $101F, $4840, $303C, $0003, $A09E;
  237.     {$ENDC}
  238. FUNCTION GetHardDiskTimeout: UInt8;
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $7004, $A09E, $1E80;
  241.     {$ENDC}
  242. PROCEDURE SetHardDiskTimeout(timeout: ByteParameter);
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $101F, $4840, $303C, $0005, $A09E;
  245.     {$ENDC}
  246. FUNCTION HardDiskPowered: BOOLEAN;
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $7006, $A09E, $1E80;
  249.     {$ENDC}
  250. PROCEDURE SpinDownHardDisk;
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $7007, $A09E;
  253.     {$ENDC}
  254. FUNCTION IsSpindownDisabled: BOOLEAN;
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $7008, $A09E, $1E80;
  257.     {$ENDC}
  258. PROCEDURE SetSpindownDisable(setDisable: BOOLEAN);
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $101F, $4840, $303C, $0009, $A09E;
  261.     {$ENDC}
  262. FUNCTION HardDiskQInstall(VAR theElement: HDQueueElement): OSErr;
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $205F, $700A, $A09E, $3E80;
  265.     {$ENDC}
  266. FUNCTION HardDiskQRemove(VAR theElement: HDQueueElement): OSErr;
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $205F, $700B, $A09E, $3E80;
  269.     {$ENDC}
  270. PROCEDURE GetScaledBatteryInfo(whichBattery: INTEGER; VAR theInfo: BatteryInfo);
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $205F, $301F, $4840, $303C, $000C, $A09E, $2080;
  273.     {$ENDC}
  274. PROCEDURE AutoSleepControl(enableSleep: BOOLEAN);
  275.     {$IFC NOT GENERATINGCFM}
  276.     INLINE $101F, $4840, $303C, $000D, $A09E;
  277.     {$ENDC}
  278. FUNCTION GetIntModemInfo: LONGINT;
  279.     {$IFC NOT GENERATINGCFM}
  280.     INLINE $700E, $A09E, $2E80;
  281.     {$ENDC}
  282. PROCEDURE SetIntModemState(theState: INTEGER);
  283.     {$IFC NOT GENERATINGCFM}
  284.     INLINE $301F, $4840, $303C, $000F, $A09E;
  285.     {$ENDC}
  286. FUNCTION MaximumProcessorSpeed: INTEGER;
  287.     {$IFC NOT GENERATINGCFM}
  288.     INLINE $7010, $A09E, $3E80;
  289.     {$ENDC}
  290. FUNCTION CurrentProcessorSpeed: INTEGER;
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $7011, $A09E, $3E80;
  293.     {$ENDC}
  294. FUNCTION FullProcessorSpeed: BOOLEAN;
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $7012, $A09E, $1E80;
  297.     {$ENDC}
  298. FUNCTION SetProcessorSpeed(fullSpeed: BOOLEAN): BOOLEAN;
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $101F, $4840, $303C, $0013, $A09E, $1E80;
  301.     {$ENDC}
  302. FUNCTION GetSCSIDiskModeAddress: INTEGER;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $7014, $A09E, $3E80;
  305.     {$ENDC}
  306. PROCEDURE SetSCSIDiskModeAddress(scsiAddress: INTEGER);
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $301F, $4840, $303C, $0015, $A09E;
  309.     {$ENDC}
  310. PROCEDURE GetWakeupTimer(VAR theTime: WakeupTime);
  311.     {$IFC NOT GENERATINGCFM}
  312.     INLINE $205F, $7016, $A09E;
  313.     {$ENDC}
  314. PROCEDURE SetWakeupTimer(VAR theTime: WakeupTime);
  315.     {$IFC NOT GENERATINGCFM}
  316.     INLINE $205F, $7017, $A09E;
  317.     {$ENDC}
  318. FUNCTION IsProcessorCyclingEnabled: BOOLEAN;
  319.     {$IFC NOT GENERATINGCFM}
  320.     INLINE $7018, $A09E, $1E80;
  321.     {$ENDC}
  322. PROCEDURE EnableProcessorCycling(enable: BOOLEAN);
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $101F, $4840, $303C, $0019, $A09E;
  325.     {$ENDC}
  326. FUNCTION BatteryCount: INTEGER;
  327.     {$IFC NOT GENERATINGCFM}
  328.     INLINE $701A, $A09E, $3E80;
  329.     {$ENDC}
  330. FUNCTION GetBatteryVoltage(whichBattery: INTEGER): Fixed;
  331.     {$IFC NOT GENERATINGCFM}
  332.     INLINE $301F, $4840, $303C, $001B, $A09E, $2E80;
  333.     {$ENDC}
  334. PROCEDURE GetBatteryTimes(whichBattery: INTEGER; VAR theTimes: BatteryTimeRec);
  335.     {$IFC NOT GENERATINGCFM}
  336.     INLINE $205F, $301F, $4840, $303C, $001C, $A09E;
  337.     {$ENDC}
  338. FUNCTION GetDimmingTimeout: UInt8;
  339.     {$IFC NOT GENERATINGCFM}
  340.     INLINE $701D, $A09E, $1E80;
  341.     {$ENDC}
  342. PROCEDURE SetDimmingTimeout(timeout: ByteParameter);
  343.     {$IFC NOT GENERATINGCFM}
  344.     INLINE $101F, $4840, $303C, $001E, $A09E;
  345.     {$ENDC}
  346. PROCEDURE DimmingControl(enableSleep: BOOLEAN);
  347.     {$IFC NOT GENERATINGCFM}
  348.     INLINE $101F, $4840, $303C, $001F, $A09E;
  349.     {$ENDC}
  350. FUNCTION IsDimmingControlDisabled: BOOLEAN;
  351.     {$IFC NOT GENERATINGCFM}
  352.     INLINE $7020, $A09E, $1E80;
  353.     {$ENDC}
  354. FUNCTION IsAutoSlpControlDisabled: BOOLEAN;
  355.     {$IFC NOT GENERATINGCFM}
  356.     INLINE $7021, $A09E, $1E80;
  357.     {$ENDC}
  358. CONST
  359.     uppHDSpindownProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  360.     uppSleepQProcInfo = $00131832; { Register FUNCTION (4 bytes in D0, 4 bytes in A0): 4 bytes in D0; }
  361.  
  362. FUNCTION NewHDSpindownProc(userRoutine: HDSpindownProcPtr): HDSpindownUPP;
  363.     {$IFC NOT GENERATINGCFM }
  364.     INLINE $2E9F;
  365.     {$ENDC}
  366.  
  367. FUNCTION NewSleepQProc(userRoutine: SleepQProcPtr): SleepQUPP;
  368.     {$IFC NOT GENERATINGCFM }
  369.     INLINE $2E9F;
  370.     {$ENDC}
  371.  
  372. PROCEDURE CallHDSpindownProc(VAR theElement: HDQueueElement; userRoutine: HDSpindownUPP);
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $205F, $4E90;
  375.     {$ENDC}
  376.  
  377. FUNCTION CallSleepQProc(message: LONGINT; qRecPtr: SleepQRecPtr; userRoutine: SleepQUPP): LONGINT;
  378.     {$IFC NOT GENERATINGCFM}
  379.     {To be implemented:  Glue to move parameters into registers.}
  380.     {$ENDC}
  381.  
  382. {$ALIGN RESET}
  383. {$POP}
  384.  
  385. {$SETC UsingIncludes := PowerIncludes}
  386.  
  387. {$ENDC} {__POWER__}
  388.  
  389. {$IFC NOT UsingIncludes}
  390.  END.
  391. {$ENDC}
  392.